JohanLe / me-app

 * @license

 * Lodash <https://lodash.com/>

 * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>

 * Released under MIT license <https://lodash.com/license>

 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>

 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors

 */

;(function() {

  /** Used as a safe reference for `undefined` in pre-ES5 environments. */

  var undefined;

  /** Used as the semantic version number. */

  var VERSION = '4.17.15';

  /** Used as the size to enable large array optimizations. */

  var LARGE_ARRAY_SIZE = 200;

  /** Error message constants. */

  var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.',

      FUNC_ERROR_TEXT = 'Expected a function';

  /** Used to stand-in for `undefined` hash values. */

  var HASH_UNDEFINED = '__lodash_hash_undefined__';

  /** Used as the maximum memoize cache size. */

  var MAX_MEMOIZE_SIZE = 500;

  /** Used as the internal argument placeholder. */

  var PLACEHOLDER = '__lodash_placeholder__';

  /** Used to compose bitmasks for cloning. */

  var CLONE_DEEP_FLAG = 1,

      CLONE_FLAT_FLAG = 2,

      CLONE_SYMBOLS_FLAG = 4;

  /** Used to compose bitmasks for value comparisons. */

  var COMPARE_PARTIAL_FLAG = 1,

      COMPARE_UNORDERED_FLAG = 2;

  /** Used to compose bitmasks for function metadata. */

  var WRAP_BIND_FLAG = 1,

      WRAP_BIND_KEY_FLAG = 2,

      WRAP_CURRY_BOUND_FLAG = 4,

      WRAP_CURRY_FLAG = 8,

      WRAP_CURRY_RIGHT_FLAG = 16,

      WRAP_PARTIAL_FLAG = 32,

      WRAP_PARTIAL_RIGHT_FLAG = 64,

      WRAP_ARY_FLAG = 128,

      WRAP_REARG_FLAG = 256,

      WRAP_FLIP_FLAG = 512;

  /** Used as default options for `_.truncate`. */

  var DEFAULT_TRUNC_LENGTH = 30,

      DEFAULT_TRUNC_OMISSION = '...';

  /** Used to detect hot functions by number of calls within a span of milliseconds. */

  var HOT_COUNT = 800,

      HOT_SPAN = 16;

  /** Used to indicate the type of lazy iteratees. */

  var LAZY_FILTER_FLAG = 1,

      LAZY_MAP_FLAG = 2,

      LAZY_WHILE_FLAG = 3;

  /** Used as references for various `Number` constants. */

  var INFINITY = 1 / 0,

      MAX_SAFE_INTEGER = 9007199254740991,

      MAX_INTEGER = 1.7976931348623157e+308,

      NAN = 0 / 0;

  /** Used as references for the maximum length and index of an array. */

  var MAX_ARRAY_LENGTH = 4294967295,

      MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,

      HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;

  /** Used to associate wrap methods with their bit flags. */

  var wrapFlags = [

    ['ary', WRAP_ARY_FLAG],

    ['bind', WRAP_BIND_FLAG],

    ['bindKey', WRAP_BIND_KEY_FLAG],

    ['curry', WRAP_CURRY_FLAG],

    ['curryRight', WRAP_CURRY_RIGHT_FLAG],

    ['flip', WRAP_FLIP_FLAG],

    ['partial', WRAP_PARTIAL_FLAG],

    ['partialRight', WRAP_PARTIAL_RIGHT_FLAG],

    ['rearg', WRAP_REARG_FLAG]

  ];

  /** `Object#toString` result references. */

  var argsTag = '[object Arguments]',

      arrayTag = '[object Array]',

      asyncTag = '[object AsyncFunction]',

      boolTag = '[object Boolean]',

      dateTag = '[object Date]',

      domExcTag = '[object DOMException]',

      errorTag = '[object Error]',

      funcTag = '[object Function]',

      genTag = '[object GeneratorFunction]',

      mapTag = '[object Map]',

      numberTag = '[object Number]',

      nullTag = '[object Null]',

      objectTag = '[object Object]',

      promiseTag = '[object Promise]',

      proxyTag = '[object Proxy]',

      regexpTag = '[object RegExp]',

      setTag = '[object Set]',

      stringTag = '[object String]',

      symbolTag = '[object Symbol]',

      undefinedTag = '[object Undefined]',

      weakMapTag = '[object WeakMap]',

      weakSetTag = '[object WeakSet]';

  var arrayBufferTag = '[object ArrayBuffer]',

      dataViewTag = '[object DataView]',

      float32Tag = '[object Float32Array]',

      float64Tag = '[object Float64Array]',

      int8Tag = '[object Int8Array]',

      int16Tag = '[object Int16Array]',

      int32Tag = '[object Int32Array]',

      uint8Tag = '[object Uint8Array]',

      uint8ClampedTag = '[object Uint8ClampedArray]',

      uint16Tag = '[object Uint16Array]',

      uint32Tag = '[object Uint32Array]';

  /** Used to match empty string literals in compiled template source. */

  var reEmptyStringLeading = /\b__p \+= '';/g,

      reEmptyStringMiddle = /\b(__p \+=) '' \+/g,

      reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;

  /** Used to match HTML entities and HTML characters. */

  var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g,

      reUnescapedHtml = /[&<>"']/g,

      reHasEscapedHtml = RegExp(reEscapedHtml.source),

      reHasUnescapedHtml = RegExp(reUnescapedHtml.source);

  /** Used to match template delimiters. */

  var reEscape = /<%-([\s\S]+?)%>/g,

      reEvaluate = /<%([\s\S]+?)%>/g,

      reInterpolate = /<%=([\s\S]+?)%>/g;

  /** Used to match property names within property paths. */

  var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,

      reIsPlainProp = /^\w*$/,

      rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;

  /**

   * Used to match `RegExp`

   * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).

   */

  var reRegExpChar = /[\\^$.*+?()[\]{}|]/g,

      reHasRegExpChar = RegExp(reRegExpChar.source);

  /** Used to match leading and trailing whitespace. */

  var reTrim = /^\s+|\s+$/g,

      reTrimStart = /^\s+/,

      reTrimEnd = /\s+$/;

  /** Used to match wrap detail comments. */

  var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,

      reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/,

      reSplitDetails = /,? & /;

  /** Used to match words composed of alphanumeric characters. */

  var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;

  /** Used to match backslashes in property paths. */

  var reEscapeChar = /\\(\\)?/g;

  /**

   * Used to match

   * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components).

   */

  var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;

  /** Used to match `RegExp` flags from their coerced string values. */

  var reFlags = /\w*$/;

  /** Used to detect bad signed hexadecimal string values. */

  var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;

  /** Used to detect binary string values. */

  var reIsBinary = /^0b[01]+$/i;

  /** Used to detect host constructors (Safari). */

  var reIsHostCtor = /^\[object .+?Constructor\]$/;

  /** Used to detect octal string values. */

  var reIsOctal = /^0o[0-7]+$/i;

  /** Used to detect unsigned integer values. */

  var reIsUint = /^(?:0|[1-9]\d*)$/;

  /** Used to match Latin Unicode letters (excluding mathematical operators). */

  var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;

  /** Used to ensure capturing order of template delimiters. */

  var reNoMatch = /($^)/;

  /** Used to match unescaped characters in compiled string literals. */

  var reUnescapedString = /['\n\r\u2028\u2029\\]/g;

  /** Used to compose unicode character classes. */

  var rsAstralRange = '\\ud800-\\udfff',

      rsComboMarksRange = '\\u0300-\\u036f',

      reComboHalfMarksRange = '\\ufe20-\\ufe2f',

      rsComboSymbolsRange = '\\u20d0-\\u20ff',

      rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,

      rsDingbatRange = '\\u2700-\\u27bf',

      rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff',

      rsMathOpRange = '\\xac\\xb1\\xd7\\xf7',

      rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf',

      rsPunctuationRange = '\\u2000-\\u206f',

      rsSpaceRange = ' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000',

      rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde',

      rsVarRange = '\\ufe0e\\ufe0f',

      rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;

  /** Used to compose unicode capture groups. */

  var rsApos = "['\u2019]",

      rsAstral = '[' + rsAstralRange + ']',

      rsBreak = '[' + rsBreakRange + ']',

      rsCombo = '[' + rsComboRange + ']',

      rsDigits = '\\d+',

      rsDingbat = '[' + rsDingbatRange + ']',

      rsLower = '[' + rsLowerRange + ']',

      rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',

      rsFitz = '\\ud83c[\\udffb-\\udfff]',

      rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',

      rsNonAstral = '[^' + rsAstralRange + ']',

      rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',

      rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',

      rsUpper = '[' + rsUpperRange + ']',

      rsZWJ = '\\u200d';

  /** Used to compose unicode regexes. */

  var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')',

      rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')',

      rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',

      rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',

      reOptMod = rsModifier + '?',

      rsOptVar = '[' + rsVarRange + ']?',

      rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',

      rsOrdLower = '\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])',

      rsOrdUpper = '\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])',

      rsSeq = rsOptVar + reOptMod + rsOptJoin,

      rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,

      rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';

  /** Used to match apostrophes. */

  var reApos = RegExp(rsApos, 'g');

  /**

   * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and

   * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).

   */

  var reComboMark = RegExp(rsCombo, 'g');

  /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */

  var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');

  /** Used to match complex or compound words. */

  var reUnicodeWord = RegExp([

    rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',

    rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')',

    rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,

    rsUpper + '+' + rsOptContrUpper,

    rsOrdUpper,

    rsOrdLower,

    rsDigits,

    rsEmoji

  ].join('|'), 'g');

  /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */

  var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboRange + rsVarRange + ']');

  /** Used to detect strings that need a more robust regexp to match words. */

  var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;

  /** Used to assign default `context` object properties. */

  var contextProps = [

    'Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array',

    'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object',

    'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array',

    'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap',

    '_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout'

  ];

  /** Used to make template sourceURLs easier to identify. */

  var templateCounter = -1;

  /** Used to identify `toStringTag` values of typed arrays. */

  var typedArrayTags = {};

  typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =

  typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =

  typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =

  typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =

  typedArrayTags[uint32Tag] = true;

  typedArrayTags[argsTag] = typedArrayTags[arrayTag] =

  typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =

  typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =

  typedArrayTags[errorTag] = typedArrayTags[funcTag] =

  typedArrayTags[mapTag] = typedArrayTags[numberTag] =

  typedArrayTags[objectTag] = typedArrayTags[regexpTag] =

  typedArrayTags[setTag] = typedArrayTags[stringTag] =

  typedArrayTags[weakMapTag] = false;

  /** Used to identify `toStringTag` values supported by `_.clone`. */

  var cloneableTags = {};

  cloneableTags[argsTag] = cloneableTags[arrayTag] =

  cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =

  cloneableTags[boolTag] = cloneableTags[dateTag] =

  cloneableTags[float32Tag] = cloneableTags[float64Tag] =

  cloneableTags[int8Tag] = cloneableTags[int16Tag] =

  cloneableTags[int32Tag] = cloneableTags[mapTag] =

  cloneableTags[numberTag] = cloneableTags[objectTag] =

  cloneableTags[regexpTag] = cloneableTags[setTag] =

  cloneableTags[stringTag] = cloneableTags[symbolTag] =

  cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =

  cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;

  cloneableTags[errorTag] = cloneableTags[funcTag] =

  cloneableTags[weakMapTag] = false;

  /** Used to map Latin Unicode letters to basic Latin letters. */

  var deburredLetters = {

    // Latin-1 Supplement block.

    '\xc0': 'A',  '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A',

    '\xe0': 'a',  '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a',

    '\xc7': 'C',  '\xe7': 'c',

    '\xd0': 'D',  '\xf0': 'd',

    '\xc8': 'E',  '\xc9': 'E', '\xca': 'E', '\xcb': 'E',

    '\xe8': 'e',  '\xe9': 'e', '\xea': 'e', '\xeb': 'e',

    '\xcc': 'I',  '\xcd': 'I', '\xce': 'I', '\xcf': 'I',

    '\xec': 'i',  '\xed': 'i', '\xee': 'i', '\xef': 'i',

    '\xd1': 'N',  '\xf1': 'n',

    '\xd2': 'O',  '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O',

    '\xf2': 'o',  '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o',

    '\xd9': 'U',  '\xda': 'U', '\xdb': 'U', '\xdc': 'U',

    '\xf9': 'u',  '\xfa': 'u', '\xfb': 'u', '\xfc': 'u',

    '\xdd': 'Y',  '\xfd': 'y', '\xff': 'y',

    '\xc6': 'Ae', '\xe6': 'ae',

    '\xde': 'Th', '\xfe': 'th',

    '\xdf': 'ss',

    // Latin Extended-A block.

    '\u0100': 'A',  '\u0102': 'A', '\u0104': 'A',

    '\u0101': 'a',  '\u0103': 'a', '\u0105': 'a',

    '\u0106': 'C',  '\u0108': 'C', '\u010a': 'C', '\u010c': 'C',

    '\u0107': 'c',  '\u0109': 'c', '\u010b': 'c', '\u010d': 'c',

    '\u010e': 'D',  '\u0110': 'D', '\u010f': 'd', '\u0111': 'd',

    '\u0112': 'E',  '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E',

    '\u0113': 'e',  '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e',

    '\u011c': 'G',  '\u011e': 'G', '\u0120': 'G', '\u0122': 'G',

    '\u011d': 'g',  '\u011f': 'g', '\u0121': 'g', '\u0123': 'g',

    '\u0124': 'H',  '\u0126': 'H', '\u0125': 'h', '\u0127': 'h',

    '\u0128': 'I',  '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I',

    '\u0129': 'i',  '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i',

    '\u0134': 'J',  '\u0135': 'j',

    '\u0136': 'K',  '\u0137': 'k', '\u0138': 'k',

    '\u0139': 'L',  '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L',

    '\u013a': 'l',  '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l',

    '\u0143': 'N',  '\u0145': 'N', '\u0147': 'N', '\u014a': 'N',

    '\u0144': 'n',  '\u0146': 'n', '\u0148': 'n', '\u014b': 'n',

    '\u014c': 'O',  '\u014e': 'O', '\u0150': 'O',

    '\u014d': 'o',  '\u014f': 'o', '\u0151': 'o',

    '\u0154': 'R',  '\u0156': 'R', '\u0158': 'R',

    '\u0155': 'r',  '\u0157': 'r', '\u0159': 'r',

    '\u015a': 'S',  '\u015c': 'S', '\u015e': 'S', '\u0160': 'S',

    '\u015b': 's',  '\u015d': 's', '\u015f': 's', '\u0161': 's',

    '\u0162': 'T',  '\u0164': 'T', '\u0166': 'T',

    '\u0163': 't',  '\u0165': 't', '\u0167': 't',

    '\u0168': 'U',  '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U',

    '\u0169': 'u',  '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u',

    '\u0174': 'W',  '\u0175': 'w',

    '\u0176': 'Y',  '\u0177': 'y', '\u0178': 'Y',

    '\u0179': 'Z',  '\u017b': 'Z', '\u017d': 'Z',

    '\u017a': 'z',  '\u017c': 'z', '\u017e': 'z',

    '\u0132': 'IJ', '\u0133': 'ij',

    '\u0152': 'Oe', '\u0153': 'oe',

    '\u0149': "'n", '\u017f': 's'

  };

  /** Used to map characters to HTML entities. */

  var htmlEscapes = {

    '&': '&',

    '<': '&lt;',

    '>': '>',

    '"': '"',

    "'": '''

  };

  /** Used to map HTML entities to characters. */

  var htmlUnescapes = {

    '&': '&',

    '&lt;': '<',

    '>': '>',

    '"': '"',

    ''': "'"

  };

  /** Used to escape characters for inclusion in compiled string literals. */

  var stringEscapes = {

    '\\': '\\',

    "'": "'",

    '\n': 'n',

    '\r': 'r',

    '\u2028': 'u2028',

    '\u2029': 'u2029'

  };

  /** Built-in method references without a dependency on `root`. */

  var freeParseFloat = parseFloat,

      freeParseInt = parseInt;

  /** Detect free variable `global` from Node.js. */

  var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;

  /** Detect free variable `self`. */

  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;

  /** Used as a reference to the global object. */

  var root = freeGlobal || freeSelf || Function('return this')();

  /** Detect free variable `exports`. */

  var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;

  /** Detect free variable `module`. */

  var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;

  /** Detect the popular CommonJS extension `module.exports`. */

  var moduleExports = freeModule && freeModule.exports === freeExports;

  /** Detect free variable `process` from Node.js. */

  var freeProcess = moduleExports && freeGlobal.process;

  /** Used to access faster Node.js helpers. */

  var nodeUtil = (function() {

    try {

      // Use `util.types` for Node.js 10+.

      var types = freeModule && freeModule.require && freeModule.require('util').types;

      if (types) {

        return types;

      }

      // Legacy `process.binding('util')` for Node.js < 10.

      return freeProcess && freeProcess.binding && freeProcess.binding('util');

    } catch (e) {}

  }());

  /* Node.js helper references. */

  var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer,

      nodeIsDate = nodeUtil && nodeUtil.isDate,

      nodeIsMap = nodeUtil && nodeUtil.isMap,

      nodeIsRegExp = nodeUtil && nodeUtil.isRegExp,

      nodeIsSet = nodeUtil && nodeUtil.isSet,

      nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;

  /*--------------------------------------------------------------------------*/

  /**

   * A faster alternative to `Function#apply`, this function invokes `func`

   * with the `this` binding of `thisArg` and the arguments of `args`.

   *

   * @private

   * @param {Function} func The function to invoke.

   * @param {*} thisArg The `this` binding of `func`.

   * @param {Array} args The arguments to invoke `func` with.

   * @returns {*} Returns the result of `func`.

   */

  function apply(func, thisArg, args) {

    switch (args.length) {

      case 0: return func.call(thisArg);

      case 1: return func.call(thisArg, args[0]);

      case 2: return func.call(thisArg, args[0], args[1]);

      case 3: return func.call(thisArg, args[0], args[1], args[2]);

    }

    return func.apply(thisArg, args);

  }

  /**

   * A specialized version of `baseAggregator` for arrays.

   *

   * @private

   * @param {Array} [array] The array to iterate over.

   * @param {Function} setter The function to set `accumulator` values.

   * @param {Function} iteratee The iteratee to transform keys.

   * @param {Object} accumulator The initial aggregated object.

   * @returns {Function} Returns `accumulator`.

   */

  function arrayAggregator(array, setter, iteratee, accumulator) {

    var index = -1,

        length = array == null ? 0 : array.length;

    while (++index < length) {

      var value = array[index];

      setter(accumulator, value, iteratee(value), array);

    }

    return accumulator;

  }

  /**

   * A specialized version of `_.forEach` for arrays without support for

   * iteratee shorthands.

   *

   * @private

   * @param {Array} [array] The array to iterate over.

   * @param {Function} iteratee The function invoked per iteration.

   * @returns {Array} Returns `array`.

   */

  function arrayEach(array, iteratee) {

    var index = -1,

        length = array == null ? 0 : array.length;

    while (++index < length) {

      if (iteratee(array[index], index, array) === false) {

        break;

      }

    }

    return array;

  }

  /**

   * A specialized version of `_.forEachRight` for arrays without support for

   * iteratee shorthands.

   *

   * @private

   * @param {Array} [array] The array to iterate over.

   * @param {Function} iteratee The function invoked per iteration.

   * @returns {Array} Returns `array`.

   */

  function arrayEachRight(array, iteratee) {

    var length = array == null ? 0 : array.length;

    while (length--) {

      if (iteratee(array[length], length, array) === false) {

        break;

      }

    }

    return array;

  }

  /**

   * A specialized version of `_.every` for arrays without support for

   * iteratee shorthands.

   *

   * @private

   * @param {Array} [array] The array to iterate over.

   * @param {Function} predicate The function invoked per iteration.

   * @returns {boolean} Returns `true` if all elements pass the predicate check,

   *  else `false`.

   */

  function arrayEvery(array, predicate) {

    var index = -1,

        length = array == null ? 0 : array.length;

    while (++index < length) {

      if (!predicate(array[index], index, array)) {

        return false;

      }

    }

    return true;

  }

  /**

   * A specialized version of `_.filter` for arrays without support for

   * iteratee shorthands.

   *

   * @private

   * @param {Array} [array] The array to iterate over.

   * @param {Function} predicate The function invoked per iteration.

   * @returns {Array} Returns the new filtered array.

   */

  function arrayFilter(array, predicate) {

    var index = -1,

        length = array == null ? 0 : array.length,

        resIndex = 0,

        result = [];

    while (++index < length) {

      var value = array[index];

      if (predicate(value, index, array)) {

        result[resIndex++] = value;

      }

    }

    return result;

  }

  /**

   * A specialized version of `_.includes` for arrays without support for

   * specifying an index to search from.

   *

   * @private

   * @param {Array} [array] The array to inspect.

   * @param {*} target The value to search for.

   * @returns {boolean} Returns `true` if `target` is found, else `false`.

   */

  function arrayIncludes(array, value) {

    var length = array == null ? 0 : array.length;

    return !!length && baseIndexOf(array, value, 0) > -1;

  }

  /**

   * This function is like `arrayIncludes` except that it accepts a comparator.

   *

   * @private

   * @param {Array} [array] The array to inspect.

   * @param {*} target The value to search for.

   * @param {Function} comparator The comparator invoked per element.

   * @returns {boolean} Returns `true` if `target` is found, else `false`.

   */

  function arrayIncludesWith(array, value, comparator) {

    var index = -1,

        length = array == null ? 0 : array.length;

    while (++index < length) {

      if (comparator(value, array[index])) {

        return true;

      }

    }

    return false;

  }

  /**

   * A specialized version of `_.map` for arrays without support for iteratee

   * shorthands.

   *

   * @private

   * @param {Array} [array] The array to iterate over.

   * @param {Function} iteratee The function invoked per iteration.

   * @returns {Array} Returns the new mapped array.

   */

  function arrayMap(array, iteratee) {

    var index = -1,

        length = array == null ? 0 : array.length,

        result = Array(length);

    while (++index < length) {

      result[index] = iteratee(array[index], index, array);

    }

    return result;

  }

  /**

   * Appends the elements of `values` to `array`.

   *

   * @private

   * @param {Array} array The array to modify.

   * @param {Array} values The values to append.

   * @returns {Array} Returns `array`.

   */

  function arrayPush(array, values) {

    var index = -1,

        length = values.length,

        offset = array.length;

    while (++index < length) {

      array[offset + index] = values[index];

    }

    return array;

  }

  /**

   * A specialized version of `_.reduce` for arrays without support for

   * iteratee shorthands.

   *

   * @private

   * @param {Array} [array] The array to iterate over.

   * @param {Function} iteratee The function invoked per iteration.

   * @param {*} [accumulator] The initial value.

   * @param {boolean} [initAccum] Specify using the first element of `array` as

   *  the initial value.

   * @returns {*} Returns the accumulated value.

   */

  function arrayReduce(array, iteratee, accumulator, initAccum) {

    var index = -1,

        length = array == null ? 0 : array.length;

    if (initAccum && length) {

      accumulator = array[++index];

    }

    while (++index < length) {

      accumulator = iteratee(accumulator, array[index], index, array);

    }

    return accumulator;

  }

  /**

   * A specialized version of `_.reduceRight` for arrays without support for

   * iteratee shorthands.

   *

   * @private

   * @param {Array} [array] The array to iterate over.

   * @param {Function} iteratee The function invoked per iteration.

   * @param {*} [accumulator] The initial value.

   * @param {boolean} [initAccum] Specify using the last element of `array` as

   *  the initial value.

   * @returns {*} Returns the accumulated value.

   */

  function arrayReduceRight(array, iteratee, accumulator, initAccum) {

    var length = array == null ? 0 : array.length;

    if (initAccum && length) {

      accumulator = array[--length];

    }

    while (length--) {

      accumulator = iteratee(accumulator, array[length], length, array);

    }

    return accumulator;

  }

  /**

   * A specialized version of `_.some` for arrays without support for iteratee

   * shorthands.

   *

   * @private

   * @param {Array} [array] The array to iterate over.

   * @param {Function} predicate The function invoked per iteration.

   * @returns {boolean} Returns `true` if any element passes the predicate check,

   *  else `false`.

   */

  function arraySome(array, predicate) {

    var index = -1,

        length = array == null ? 0 : array.length;

    while (++index < length) {

      if (predicate(array[index], index, array)) {

        return true;

      }

    }

    return false;

  }

  /**

   * Gets the size of an ASCII `string`.

   *

   * @private

   * @param {string} string The string inspect.

   * @returns {number} Returns the string size.

   */

  var asciiSize = baseProperty('length');

  /**

   * Converts an ASCII `string` to an array.

   *

   * @private

   * @param {string} string The string to convert.

   * @returns {Array} Returns the converted array.

   */

  function asciiToArray(string) {

    return string.split('');

  }

  /**

   * Splits an ASCII `string` into an array of its words.

   *

   * @private

   * @param {string} The string to inspect.

   * @returns {Array} Returns the words of `string`.

   */

  function asciiWords(string) {

    return string.match(reAsciiWord) || [];

  }

  /**

   * The base implementation of methods like `_.findKey` and `_.findLastKey`,

   * without support for iteratee shorthands, which iterates over `collection`

   * using `eachFunc`.

   *

   * @private

   * @param {Array|Object} collection The collection to inspect.

   * @param {Function} predicate The function invoked per iteration.

   * @param {Function} eachFunc The function to iterate over `collection`.

   * @returns {*} Returns the found element or its key, else `undefined`.

   */

  function baseFindKey(collection, predicate, eachFunc) {

    var result;

    eachFunc(collection, function(value, key, collection) {

      if (predicate(value, key, collection)) {

        result = key;

        return false;

      }

    });

    return result;

  }

  /**

   * The base implementation of `_.findIndex` and `_.findLastIndex` without

   * support for iteratee shorthands.

   *

   * @private

   * @param {Array} array The array to inspect.

   * @param {Function} predicate The function invoked per iteration.

   * @param {number} fromIndex The index to search from.

   * @param {boolean} [fromRight] Specify iterating from right to left.

   * @returns {number} Returns the index of the matched value, else `-1`.

   */

  function baseFindIndex(array, predicate, fromIndex, fromRight) {

    var length = array.length,

        index = fromIndex + (fromRight ? 1 : -1);

    while ((fromRight ? index-- : ++index < length)) {

      if (predicate(array[index], index, array)) {

        return index;

      }

    }

    return -1;

  }

  /**

   * The base implementation of `_.indexOf` without `fromIndex` bounds checks.

   *

   * @private

   * @param {Array} array The array to inspect.

   * @param {*} value The value to search for.

   * @param {number} fromIndex The index to search from.

   * @returns {number} Returns the index of the matched value, else `-1`.

   */

  function baseIndexOf(array, value, fromIndex) {

    return value === value

      ? strictIndexOf(array, value, fromIndex)

      : baseFindIndex(array, baseIsNaN, fromIndex);

  }

  /**

   * This function is like `baseIndexOf` except that it accepts a comparator.

   *

   * @private

   * @param {Array} array The array to inspect.

   * @param {*} value The value to search for.

   * @param {number} fromIndex The index to search from.

   * @param {Function} comparator The comparator invoked per element.

   * @returns {number} Returns the index of the matched value, else `-1`.

   */

  function baseIndexOfWith(array, value, fromIndex, comparator) {

    var index = fromIndex - 1,

        length = array.length;

    while (++index < length) {

      if (comparator(array[index], value)) {

        return index;

      }

    }

    return -1;

  }

  /**

   * The base implementation of `_.isNaN` without support for number objects.

   *

   * @private

   * @param {*} value The value to check.

   * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.

   */

  function baseIsNaN(value) {

    return value !== value;

  }

  /**

   * The base implementation of `_.mean` and `_.meanBy` without support for

   * iteratee shorthands.

   *

   * @private

   * @param {Array} array The array to iterate over.

   * @param {Function} iteratee The function invoked per iteration.

   * @returns {number} Returns the mean.

   */

  function baseMean(array, iteratee) {

    var length = array == null ? 0 : array.length;

    return length ? (baseSum(array, iteratee) / length) : NAN;

  }

  /**

   * The base implementation of `_.property` without support for deep paths.

   *

   * @private

   * @param {string} key The key of the property to get.

   * @returns {Function} Returns the new accessor function.

   */

  function baseProperty(key) {

    return function(object) {

      return object == null ? undefined : object[key];

    };

  }

  /**

   * The base implementation of `_.propertyOf` without support for deep paths.

   *

   * @private

   * @param {Object} object The object to query.

   * @returns {Function} Returns the new accessor function.

   */

  function basePropertyOf(object) {

    return function(key) {

      return object == null ? undefined : object[key];

    };

  }

  /**

   * The base implementation of `_.reduce` and `_.reduceRight`, without support

   * for iteratee shorthands, which iterates over `collection` using `eachFunc`.

   *

   * @private

   * @param {Array|Object} collection The collection to iterate over.

   * @param {Function} iteratee The function invoked per iteration.

   * @param {*} accumulator The initial value.

   * @param {boolean} initAccum Specify using the first or last element of

   *  `collection` as the initial value.

   * @param {Function} eachFunc The function to iterate over `collection`.

   * @returns {*} Returns the accumulated value.

   */

  function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {

    eachFunc(collection, function(value, index, collection) {

      accumulator = initAccum

        ? (initAccum = false, value)

        : iteratee(accumulator, value, index, collection);

    });

    return accumulator;

  }

  /**

   * The base implementation of `_.sortBy` which uses `comparer` to define the

   * sort order of `array` and replaces criteria objects with their corresponding

   * values.

   *

   * @private

   * @param {Array} array The array to sort.

   * @param {Function} comparer The function to define sort order.

   * @returns {Array} Returns `array`.

   */

  function baseSortBy(array, comparer) {

    var length = array.length;

    array.sort(comparer);

    while (length--) {

      array[length] = array[length].value;

    }

    return array;

  }

  /**

   * The base implementation of `_.sum` and `_.sumBy` without support for

   * iteratee shorthands.

   *

   * @private

   * @param {Array} array The array to iterate over.

   * @param {Function} iteratee The function invoked per iteration.

   * @returns {number} Returns the sum.

   */

  function baseSum(array, iteratee) {

    var result,

        index = -1,

        length = array.length;

    while (++index < length) {

      var current = iteratee(array[index]);

      if (current !== undefined) {

        result = result === undefined ? current : (result + current);

      }

    }

    return result;

  }

  /**

   * The base implementation of `_.times` without support for iteratee shorthands

   * or max array length checks.

   *

   * @private

   * @param {number} n The number of times to invoke `iteratee`.

   * @param {Function} iteratee The function invoked per iteration.

   * @returns {Array} Returns the array of results.

   */

  function baseTimes(n, iteratee) {

    var index = -1,

        result = Array(n);

    while (++index < n) {

      result[index] = iteratee(index);

    }

    return result;

  }

  /**

   * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array

   * of key-value pairs for `object` corresponding to the property names of `props`.

   *

   * @private

   * @param {Object} object The object to query.

   * @param {Array} props The property names to get values for.

   * @returns {Object} Returns the key-value pairs.

   */

  function baseToPairs(object, props) {

    return arrayMap(props, function(key) {

      return [key, object[key]];

    });

  }

  /**

   * The base implementation of `_.unary` without support for storing metadata.

   *

   * @private

   * @param {Function} func The function to cap arguments for.

   * @returns {Function} Returns the new capped function.

   */

  function baseUnary(func) {

    return function(value) {

      return func(value);

    };

  }

  /**

   * The base implementation of `_.values` and `_.valuesIn` which creates an

   * array of `object` property values corresponding to the property names

   * of `props`.

   *

   * @private

   * @param {Object} object The object to query.

   * @param {Array} props The property names to get values for.

   * @returns {Object} Returns the array of property values.

   */

  function baseValues(object, props) {

    return arrayMap(props, function(key) {

      return object[key];

    });

  }

  /**

   * Checks if a `cache` value for `key` exists.

   *

   * @private

   * @param {Object} cache The cache to query.

   * @param {string} key The key of the entry to check.

   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.

   */

  function cacheHas(cache, key) {

    return cache.has(key);

  }

  /**

   * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol

   * that is not found in the character symbols.

   *

   * @private

   * @param {Array} strSymbols The string symbols to inspect.

   * @param {Array} chrSymbols The character symbols to find.

   * @returns {number} Returns the index of the first unmatched string symbol.

   */

  function charsStartIndex(strSymbols, chrSymbols) {

    var index = -1,

        length = strSymbols.length;

    while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}

    return index;

  }

  /**

   * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol

   * that is not found in the character symbols.

   *

   * @private

   * @param {Array} strSymbols The string symbols to inspect.

   * @param {Array} chrSymbols The character symbols to find.

   * @returns {number} Returns the index of the last unmatched string symbol.

   */

  function charsEndIndex(strSymbols, chrSymbols) {

    var index = strSymbols.length;

    while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}

    return index;

  }

  /**

   * Gets the number of `placeholder` occurrences in `array`.

   *

   * @private

   * @param {Array} array The array to inspect.

   * @param {*} placeholder The placeholder to search for.

   * @returns {number} Returns the placeholder count.

   */

  function countHolders(array, placeholder) {

    var length = array.length,

        result = 0;

    while (length--) {

      if (array[length] === placeholder) {

        ++result;

      }

    }

    return result;

  }

  /**

   * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A

   * letters to basic Latin letters.

   *

   * @private

   * @param {string} letter The matched letter to deburr.

   * @returns {string} Returns the deburred letter.

   */

  var deburrLetter = basePropertyOf(deburredLetters);

  /**

   * Used by `_.escape` to convert characters to HTML entities.

   *

   * @private

   * @param {string} chr The matched character to escape.

   * @returns {string} Returns the escaped character.

   */

  var escapeHtmlChar = basePropertyOf(htmlEscapes);